package tests;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.HashSet;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import services.MoteurJeuService;
import services.TerrainService;
import utils.Commande;
import utils.Resultat;
import utils.Sante;
import contracts.ContractException;

public abstract class AbstractMoteurJeuTest {
	private MoteurJeuService moteurJeu;

	protected AbstractMoteurJeuTest(){
		this.moteurJeu = null;
	}


	protected final MoteurJeuService getMoteurJeu(){
		return this.moteurJeu;
	}

	protected final void setMoteurJeu(MoteurJeuService moteurJeu){
		this.moteurJeu = moteurJeu;
	}

	@Before
	public abstract void beforeTests(); 


	@After
	public final void afterTests() {
		this.moteurJeu = null;
	}

	/**
	 * Test de l'objectif 1
	 * precondition de getBombe(M, num) : bombeExiste(M, num)
	 * cas de test 1.1 : bombeExiste(M, 0) = true
	 */
	@Test
	public void testGetBombe1(){
		try{
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
			Assert.assertTrue(this.moteurJeu.bombeExiste(0));
		}catch(ContractException e){e.printStackTrace();}
		Assert.assertTrue(this.moteurJeu.bombeExiste(0));
	}

	/**
	 * Test de l'objectif 1
	 * precondition de getBombe(M, num) : bombeExiste(M, num)
	 * cas de test 1.2 : bombeExiste(M, 0) = false
	 */
	@Test
	public void testGetBombe2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {e.printStackTrace();}
		Assert.assertTrue(!(this.moteurJeu.bombeExiste(0)));
	}


	/**
	 * Test de l'objectif 2
	 * precondition de resultatFinal(M) : estFini(M)
	 * cas de test 2.1 : estFini(M) = true
	 */
	@Test
	public void testResultatFinal1(){
		try {
			//conditions initiales
			this.moteurJeu.init(1);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {e.printStackTrace();}
		assertTrue(this.moteurJeu.estFini());
	}

	/**
	 * Test de l'objectif 2
	 * precondition de resultatFinal(M) : estFini(M)
	 * cas de test 2.2 : estFini(M) = false
	 */
	@Test
	public void testResultatFinal2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {e.printStackTrace();}
		assertTrue(!(this.moteurJeu.estFini()));
	}

	/**
	 * Test de l'objectif 3
	 * precondition de misEnJoue(M, x, y, num) : bombeExiste(M, num)
	 * cas de test 3.1 : bombeExiste(M, num) = true
	 * @throws ContractException 
	 */
	@Test
	public void testMisEnJoue1() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {e.printStackTrace();}
		assertTrue(this.moteurJeu.misEnJoue(2, 2, 0));
	}

	/**
	 * Test de l'objectif 3
	 * precondition de misEnJoue(M, x, y, num) : bombeExiste(M, num)
	 * cas de test 3.2 : bombeExiste(M, num) = false
	 * @throws ContractException 
	 */
	@Test(expected=ContractException.class)
	public void testMisEnJoue2() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {e.printStackTrace();}
		this.moteurJeu.misEnJoue(2, 2, 0);
	}

	/**
	 * Test de l'objectif 4
	 * precondition de init(maxPasJeu) require maxPasJeu >=0
	 * cas de test 4.1 : maxPasJeu < 0
	 * @throws ContractException 
	 */
	@Test(expected=ContractException.class)
	public void testInit1() throws ContractException{
		this.moteurJeu.init(-1);
	}

	/**
	 * Test de l'objectif 4
	 * precondition de init(maxPasJeu) require maxPasJeu >=0
	 * cas de test 4.2 : maxPasJeu = 0
	 */
	@Test
	public void testInit2(){
		try {
			this.moteurJeu.init(0);
		} catch (ContractException e) {
			e.printStackTrace();
			fail("MoteurJeu 4.2 : envoie erratique d'exception sur precondition de init.");
		}
		assertTrue(true);
	}

	/**
	 * Test de l'objectif 4
	 * precondition de init(maxPasJeu) require maxPasJeu >=0
	 * cas de test 4.3 : maxPasJeu > 0
	 */
	@Test
	public void testInit3(){
		try {
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			fail("MoteurJeu 4.3 : envoi erratique d'exception sur precondition de init.");
		}
		assertTrue(true);
	}

	/**
	 * Test de l'objectif 5
	 * precondition de pasJeu(M, c) : !(estFini(M))
	 * cas de test 5.1 : estFini = true
	 * @throws ContractException 
	 */
	@org.junit.Test(expected=ContractException.class)
	public void testPasJeu1() throws ContractException{

		//conditions initiales
		this.moteurJeu.init(1);
		this.moteurJeu.pasJeu(Commande.BOMBE, true);

		this.moteurJeu.pasJeu(Commande.BOMBE, true);
	}

	/**
	 * Test de l'objectif 5
	 * precondition de pasJeu(M, c) : !(estFini(M))
	 * cas de test 5.2 : estFini = false
	 * @throws ContractException 
	 */
	@Test
	public void testPasJeu2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {e.printStackTrace();}
		try {
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			fail("MoteurJeu 5.2 : envoi erratique d'exception sur precondition de pasJeu");
		}
		assertTrue(true);
	}

	/**
	 * Test de l'objectif 6
	 * invariant 0 <= getPasJeuCourant(M) <= getMaxPasJeu(M)
	 * cas de test 6.1 : getPasJeuCourant(M) < 0
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 6
	 * invariant 0 <= getPasJeuCourant(M) <= getMaxPasJeu(M)
	 * cas de test 6.2 : getPasJeuCourant(M) = 0
	 */
	@Test
	public void testInvariantGetPasJeuCourant2(){
		try {
			//conditions initiales
			this.moteurJeu.init(0);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getPasJeuCourrant() == 0);
	}

	/**
	 * Test de l'objectif 6
	 * invariant 0 <= getPasJeuCourant(M) <= getMaxPasJeu(M)
	 * cas de test 6.3 : getPasJeuCourant(M) > 0 et getPasJeuCourant < getMaxPasJeu(M)
	 * @throws Exception 
	 */
	@Test
	public void testInvariantGetPasJeuCourant3(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);

			this.moteurJeu.pasJeu(Commande.BOMBE, true);

			this.moteurJeu.pasJeu(Commande.BOMBE, true);


		} catch (ContractException e) {
			e.printStackTrace();
			Assert.fail("MoteurJeu 6.3 "+e.getMessage());
		}
		Assert.assertTrue(this.moteurJeu.getPasJeuCourrant() > 0 && this.moteurJeu.getPasJeuCourrant() < this.moteurJeu.getMaxPasJeu());
	}

	/**
	 * Test de l'objectif 6
	 * invariant 0 <= getPasJeuCourant(M) <= getMaxPasJeu(M)
	 * cas de test 6.4 : getPasJeuCourant(M) = getMaxPasJeu(M)
	 */
	@Test
	public void testInvariantGetPasJeuCourant4(){
		try {
			//conditions initiales
			this.moteurJeu.init(2);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
			Assert.fail("MoteurJeu 6.4 "+e.getMessage());
		}
		assertTrue(this.moteurJeu.getPasJeuCourrant() == this.moteurJeu.getMaxPasJeu());
	}

	/**
	 * Test de l'objectif 6
	 * invariant 0 <= getPasJeuCourant(M) <= getMaxPasJeu(M)
	 * cas de test 6.5 : getPasJeuCourant(M) > getMaxPasJeu(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 7
	 * invariant 1 <= getHerosX(M) <= Terrain :getNombreColonnes(getTerrain(M))
	 * cas de test 7.1 : getHerosX(M) < 1
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 7
	 * invariant 1 <= getHerosX(M) <= Terrain :getNombreColonnes(getTerrain(M))
	 * cas de test 7.2 : getHerosX(M) = 1
	 */
	@Test
	public void testInvariantGetHerosX2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.GAUCHE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == 1);
	}

	/**
	 * Test de l'objectif 7
	 * invariant 1 <= getHerosX(M) <= Terrain :getNombreColonnes(getTerrain(M))
	 * cas de test 7.3 : getHerosX(M) > 1 et getHerosX(M) < Terrain :getNombreColonnes(getTerrain(M))
	 */
	@Test
	public void testInvariantGetHerosX3(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() > 1 && this.moteurJeu.getHerosX() < this.moteurJeu.getTerrain().getNombreColonnes());
	}

	/**
	 * Test de l'objectif 7
	 * invariant 1 <= getHerosX(M) <= Terrain :getNombreColonnes(getTerrain(M))
	 * cas de test 7.4 : getHerosX(M) = Terrain :getNombreColonnes(getTerrain(M))
	 */
	@Test
	public void testInvariantGetHerosX4(){
		try {
			//conditions initiales
			this.moteurJeu.init(20);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == this.moteurJeu.getTerrain().getNombreColonnes());
	}

	/**
	 * Test de l'objectif 7
	 * invariant 1 <= getHerosX(M) <= Terrain :getNombreColonnes(getTerrain(M))
	 * cas de test 7.5 : getHerosX(M) > Terrain :getNombreColonnes(getTerrain(M))
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 8
	 * invariant 1 <= getHerosY(M) <= Terrain :getNombreLignes(getTerrain(M))
	 * cas de test 8.1 : getHerosY(M) < 1
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 8
	 * invariant 1 <= getHerosY(M) <= Terrain :getNombreLignes(getTerrain(M))
	 * cas de test 8.2 : getHerosY(M) = 1
	 */
	@Test
	public void testInvariantGetHerosY2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.HAUT, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == 1);
	}

	/**
	 * Test de l'objectif 8
	 * invariant 1 <= getHerosY(M) <= Terrain :getNombreLignes(getTerrain(M))
	 * cas de test 8.3 : getHerosY(M) > 1 et getHerosY(M) < Terrain :getNombreLignes(getTerrain(M))
	 */
	@Test
	public void testInvariantGetHerosY3(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BAS, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() > 1 && this.moteurJeu.getHerosY() < this.moteurJeu.getTerrain().getNombreLignes());
	}

	/**
	 * Test de l'objectif 8
	 * invariant 1 <= getHerosY(M) <= Terrain :getNombreLignes(getTerrain(M))
	 * cas de test 8.4 : getHerosY(M) = Terrain :getNombreLignes(getTerrain(M))
	 */
	@Test
	public void testInvariantGetHerosY4(){
		try {
			//conditions initiales
			this.moteurJeu.init(20);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == this.moteurJeu.getTerrain().getNombreLignes());
	}

	/**
	 * Test de l'objectif 8
	 * invariant 1 <= getHerosY(M) <= Terrain :getNombreLignes(getTerrain(M))
	 * cas de test 8.5 : getHerosY(M) > Terrain :getNombreLignes(getTerrain(M))
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 9
	 * invariant 3 <= getHerosForceVitale(M) <= 11
	 * cas de test 9.1 : getHerosForceVitale(M) < 3
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 9
	 * invariant 3 <= getHerosForceVitale(M) <= 11
	 * cas de test 9.2 : getHerosForceVitale(M) = 3
	 */
	@Test
	public void testInvariantGetHerosForceVitale2(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosForceVitale() == 3);
	}

	/**
	 * Test de l'objectif 9
	 * invariant 3 <= getHerosForceVitale(M) <= 11
	 * cas de test 9.3 : getHerosForceVitale(M) > 3 et getHerosForceVitale(M) < 11
	 */
	@Test
	public void testInvariantGetHerosForceVitale3(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		//comment augmenter la force vitale ?
		assertTrue((this.moteurJeu.getHerosForceVitale() >= 3) && (this.moteurJeu.getHerosForceVitale() < 11));
	}

	/**
	 * Test de l'objectif 9
	 * invariant 3 <= getHerosForceVitale(M) <= 11
	 * cas de test 9.4 : getHerosForceVitale(M) = 11
	 */
	@Test
	public void testInvariantGetHerosForceVitale4(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		//comment augmenter la force vitale ?
		assertTrue(this.moteurJeu.getHerosForceVitale() <= 11);
	}

	/**
	 * Test de l'objectif 9
	 * invariant 3 <= getHerosForceVitale(M) <= 11
	 * cas de test 9.5 : getHerosForceVitale(M) > 11
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 10
	 * invariant getNbBombes(M) = | getBombeNumeros(M) |
	 * cas de test 10.1 : getNbBombes(M) = | getBombeNumeros(M) |
	 */
	@Test
	public void testInvariantGetNbBombes1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getNbBombes() == this.moteurJeu.getBombeNumeros().size());
	}

	/**
	 * Test de l'objectif 10
	 * invariant getNbBombes(M) = | getBombeNumeros(M) |
	 * cas de test 10.2 : getNbBombes(M) != | getBombeNumeros(M) |
	 * On ne peut atteindre cet etat
	 */

	/**
	 * Test de l'objectif 11
	 * invariant bombeExiste(M, num) = (num appartient a getBombeNumeros(M))
	 * cas de test 11.1 : bombeExiste(M, num) = (num appartient a getBombeNumeros(M))
	 */
	@Test
	public void testInvariantBombeExiste1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.bombeExiste(0));
	}

	/**
	 * Test de l'objectif 11
	 * invariant bombeExiste(M, num) = (num appartient a getBombeNumeros(M))
	 * cas de test 11.2 : bombeExiste(M, num) != (num appartient a getBombeNumeros(M))
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.1 : estFini = true et getHerosSante(M) != SANTE.MORT et getPasJeuCourant(M) != getMaxPasJeu(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.2 : estFini = true et getHerosSante(M) != SANTE.MORT et getPasJeuCourant(M) = getMaxPasJeu(M)
	 */
	@Test
	public void testInvariantEstFini2(){
		try {
			//conditions initiales
			this.moteurJeu.init(1);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.estFini() == (this.moteurJeu.getPasJeuCourrant() == this.moteurJeu.getMaxPasJeu()));
	}

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.3 : estFini = true et getHerosSante(M) = SANTE.MORT et getPasJeuCourant(M) != getMaxPasJeu(M)
	 */
	@Test
	public void testInvariantEstFini3(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		//comment tuer le joueur ?
		assertTrue(this.moteurJeu.estFini() == (this.moteurJeu.getHerosSante() == Sante.MORT));
	}

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.4 : estFini = true et getHerosSante(M) = SANTE.MORT et getPasJeuCourant(M) = getMaxPasJeu(M)
	 */
	@Test
	public void testInvariantEstFini4(){
		try {
			//conditions initiales
			this.moteurJeu.init(1);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		//comment tuer le joueur ?

		assertTrue(this.moteurJeu.estFini() == ((this.moteurJeu.getHerosSante() == Sante.MORT) || 
				(this.moteurJeu.getPasJeuCourrant() == this.moteurJeu.getMaxPasJeu())));
	}

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.5 : estFini = false et getHerosSante(M) != SANTE.MORT et getPasJeuCourant(M) != getMaxPasJeu(M)
	 */
	@Test
	public void testInvariantEstFini5(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			fail("MoteurJeu 12.5 : envoi erratique d'exception sur invariant de estFini.");
		}
		//comment tuer le joueur ?
		assertTrue(this.moteurJeu.estFini() == 
				(	(this.moteurJeu.getHerosSante() == Sante.MORT) ||	(this.moteurJeu.getPasJeuCourrant() == this.moteurJeu.getMaxPasJeu() ) )	);
	}

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.6 : estFini = false et getHerosSante(M) != SANTE.MORT et getPasJeuCourant(M) = getMaxPasJeu(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.7 : estFini = false et getHerosSante(M) = SANTE.MORT et getPasJeuCourant(M) != getMaxPasJeu(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 12
	 * invariant estFini(M) = (getHerosSante(M) = SANTE.MORT ou getPasJeuCourant(M) = getMaxPasJeu(M))
	 * cas de test 12.8 : estFini = false et getHerosSante(M) = SANTE.MORT et getPasJeuCourant(M) = getMaxPasJeu(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 13
	 * invariant (resultatFinal(M) = RESULTAT.KIDNAPPEURGAGNE) = (getHerosSante(M) = SANTE.MORT)
	 * cas de test 13.1 : (resultatFinal(M) = RESULTAT.KIDNAPPEURGAGNE) = (getHerosSante(M) = SANTE.MORT)
	 * @throws ContractException 
	 */
	@Test
	public void testInvariantResultatFinal1() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			e.printStackTrace();
			fail("MoteurJeu 13.1 : envoi erratique d'exception sur invariant de resultatFinal.");
		}
		//comment arriver dans cet etat ?
		assertTrue((this.moteurJeu.estFini() &&(this.moteurJeu.resultatFinal() == Resultat.KIDNAPPEURGAGNE)) ==
				(this.moteurJeu.estFini() &&(this.moteurJeu.getHerosSante() == Sante.MORT)));
	}

	/**
	 * Test de l'objectif 13
	 * invariant (resultatFinal(M) = RESULTAT.KIDNAPPEURGAGNE) = (getHerosSante(M) = SANTE.MORT)
	 * cas de test 13.2 : (resultatFinal(M) = RESULTAT.KIDNAPPEURGAGNE) != (getHerosSante(M) = SANTE.MORT)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 14
	 * invariant (resultatFinal(M) = RESULTAT.PARTIENULLE) = (getHerosSante(M) = SANTE.VIVANT)
	 * cas de test 14.1 : (resultatFinal(M) = RESULTAT.PARTIENULLE) = (getHerosSante(M) = SANTE.VIVANT)
	 * @throws ContractException 
	 */
	@Test
	public void testInvariantResultatFinal2_1() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(1);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			fail("MoteurJeu 14.1 : envoie erratique d'exception sur invariant de resultatFinal.");		
		}
		assertTrue((this.moteurJeu.resultatFinal() == Resultat.PARTIENULLE) == (this.moteurJeu.getHerosSante() == Sante.VIVANT));
	}

	/**
	 * Test de l'objectif 14
	 * invariant (resultatFinal(M) = RESULTAT.PARTIENULLE) = (getHerosSante(M) = SANTE.VIVANT)
	 * cas de test 14.2 : (resultatFinal(M) = RESULTAT.PARTIENULLE) != (getHerosSante(M) = SANTE.VIVANT)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 15
	 * invariant misEnJoue(M, x, y, num) = 
	 * (xB = Bombe :getX(getBombe(M, num))) et (yB = Bombe :getY(getBombe(M, num))) et 
	 * (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * ((x = xB et | y e yB | <= aB) ou (y = yB et | x e xB | <= aB))
	 * cas de test 15.1 : (xB != Bombe :getX(getBombe(M, num))) ou 
	 * (yB != Bombe :getY(getBombe(M, num))) ou (aB != Bombe :getAmplitude(getBombe(M, num)))
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 15
	 * invariant misEnJoue(M, x, y, num) = 
	 * (xB = Bombe :getX(getBombe(M, num))) et 
	 * (yB = Bombe :getY(getBombe(M, num))) et 
	 * (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * ((x = xB et | y -  yB | <= aB) ou (y = yB et | x -xB | <= aB))
	 * cas de test 15.2 : 
	 * (xB = Bombe :getX(getBombe(M, num))) et 
	 * (yB = Bombe :getY(getBombe(M, num))) et 
	 * (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * ((x != xB ou | y  - yB | > aB) et (y != yB ou | x- xB | > aB))
	 * @throws ContractException 
	 */
	@Test
	public void testInvariantMisEnJoue2() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			Assert.fail("MoteurJeu 15.2 : envoi erratique d'exception sur invariant misEnJoue.");
		}
		int xHero = this.moteurJeu.getHerosX();
		int yHero = this.moteurJeu.getHerosY();
		int xBomb = this.moteurJeu.getBombe(0).getX();
		int yBomb = this.moteurJeu.getBombe(0).getY();
		int aBomb = this.moteurJeu.getBombe(0).getAmplitude();
		assertFalse(
				( xHero != xBomb || (Math.abs(yHero - yBomb) > aBomb))  && 
				( yHero != yBomb || (Math.abs(xHero - xBomb) > aBomb))		);
	}

	/**
	 * Test de l'objectif 15
	 * invariant misEnJoue(M, x, y, num) = 
	 * (xB = Bombe :getX(getBombe(M, num))) et (yB = Bombe :getY(getBombe(M, num))) et 
	 * (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * ((x = xB et | y e yB | <= aB) ou (y = yB et | x e xB | <= aB))
	 * cas de test 15.3 : (xB = Bombe :getX(getBombe(M, num))) et 
	 * (yB = Bombe :getY(getBombe(M, num))) et (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * (x = xB et | y e yB | <= aB)
	 * @throws ContractException 
	 */
	@Test
	public void testInvariantMisEnJoue3() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == this.moteurJeu.getBombe(0).getX() &&
				Math.abs(this.moteurJeu.getHerosY() - this.moteurJeu.getBombe(0).getY()) <=
				this.moteurJeu.getBombe(0).getAmplitude());
	}

	/**
	 * Test de l'objectif 15
	 * invariant misEnJoue(M, x, y, num) = 
	 * (xB = Bombe :getX(getBombe(M, num))) et (yB = Bombe :getY(getBombe(M, num))) et 
	 * (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * ((x = xB et | y e yB | <= aB) ou (y = yB et | x e xB | <= aB))
	 * cas de test 15.4 : (xB = Bombe :getX(getBombe(M, num))) et 
	 * (yB = Bombe :getY(getBombe(M, num))) et (aB = Bombe :getAmplitude(getBombe(M, num))) et 
	 * (y = yB et | x e xB | <= aB)
	 * @throws ContractException 
	 */
	@Test
	public void testInvariantMisEnJoue4() throws ContractException{
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == this.moteurJeu.getBombe(0).getY() &&
				Math.abs(this.moteurJeu.getHerosX() - this.moteurJeu.getBombe(0).getX()) <=
				this.moteurJeu.getBombe(0).getAmplitude());
	}

	/**
	 * Test de l'objectif 16
	 * postcondition de init : getMaxPasJeu(init(p)) = p
	 * cas de test 16.1 : getMaxPasJeu(init(p)) = p
	 */
	@Test
	public void testPostcondGetMaxPasJeu1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getMaxPasJeu() == 10);
	}

	/**
	 * Test de l'objectif 16
	 * postcondition de init : getMaxPasJeu(init(p)) = p
	 * cas de test 16.2 : getMaxPasJeu(init(p)) != p
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 17
	 * postcondition de init : getPasJeuCourant(init(p)) = 0
	 * cas de test 17.1 : getPasJeuCourant(init(p)) = 0
	 */
	@Test
	public void testPostcondGetPasJeuCourant1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getPasJeuCourrant() == 0);
	}

	/**
	 * Test de l'objectif 17
	 * postcondition de init : getPasJeuCourant(init(p)) = 0
	 * cas de test 17.2 : getPasJeuCourant(init(p)) != 0
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 18
	 * postcondition de init : getHerosX(init(p)) = 2
	 * cas de test 18.1 : getHerosX(init(p)) = 2
	 */
	@Test
	public void testPostcondGetHerosX1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == 2);
	}

	/**
	 * Test de l'objectif 18
	 * postcondition de init : getHerosX(init(p)) = 2
	 * cas de test 18.2 : getHerosX(init(p)) != 2
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 19
	 * postcondition de init : getHerosY(init(p)) = 2
	 * cas de test 19.1 : getHerosY(init(p)) = 2
	 */
	@Test
	public void testPostcondGetHerosY1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == 2);
	}

	/**
	 * Test de l'objectif 19
	 * postcondition de init : getHerosY(init(p)) = 2
	 * cas de test 19.2 : getHerosY(init(p)) != 2
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 20
	 * postcondition de init : getHerosSante(init(p)) = SANTE.VIVANT
	 * cas de test 20.1 : getHerosSante(init(p)) = SANTE.VIVANT
	 */
	@Test
	public void testPostcondGetHerosSante1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosSante() == Sante.VIVANT);
	}

	/**
	 * Test de l'objectif 20
	 * postcondition de init : getHerosSante(init(p)) = SANTE.VIVANT
	 * cas de test 20.2 : getHerosSante(init(p)) != SANTE.VIVANT
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 21
	 * postcondition de init : getHerosForceVitale(init(p)) = 3
	 * cas de test 21.1 : getHerosForceVitale(init(p)) = 3
	 */
	@Test
	public void testPostcondGetHerosForceVitale1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosForceVitale() == 3);
	}

	/**
	 * Test de l'objectif 21
	 * postcondition de init : getHerosForceVitale(init(p)) = 3
	 * cas de test 21.2 : getHerosForceVitale(init(p)) != 3
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 22
	 * postcondition de init : Terrain :getNombreColonnes(getTerrain(init(p))) = 15
	 * cas de test 22.1 : getNombreColonnes(getTerrain(init(p))) = 15
	 */
	@Test
	public void testPostcondGetNombreColonnes1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getTerrain().getNombreColonnes() == 15);
	}

	/**
	 * Test de l'objectif 22
	 * postcondition de init : Terrain :getNombreColonnes(getTerrain(init(p))) = 15
	 * cas de test 22.2 : getNombreColonnes(getTerrain(init(p))) != 15
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 23
	 * postcondition de init : Terrain :getNombreLignes(getTerrain(init(p))) = 13
	 * cas de test 23.1 : getNombreLignes(getTerrain(init(p))) = 13
	 */
	@Test
	public void testPostcondGetNombreLignes1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getTerrain().getNombreLignes() == 13);
	}

	/**
	 * Test de l'objectif 23
	 * postcondition de init : Terrain :getNombreLignes(getTerrain(init(p))) = 13
	 * cas de test 23.2 : getNombreLignes(getTerrain(init(p))) != 13
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 24
	 * postcondition de init : getBombeNumeros(init(p)) = ens vide
	 * cas de test 24.1 : getBombeNumeros(init(p)) = ens vide
	 */
	@Test
	public void testPostcondGetBombeNumeros1(){
		try {
			//conditions initiales
			this.moteurJeu.init(10);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getBombeNumeros().equals(new HashSet<Integer>()));
	}

	/**
	 * Test de l'objectif 24
	 * postcondition de init : getBombeNumeros(init(p)) = ens vide
	 * cas de test 24.2 : getBombeNumeros(init(p)) != ens vide
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 25
	 * postcondition de pasJeu : getPasJeuCourant(pasJeu(M, c)) = getPasJeuCourant(M) + 1
	 * cas de test 25.1 : getPasJeuCourant(pasJeu(M, c)) = getPasJeuCourant(M) + 1
	 */
	@Test
	public void testPostcondPasJeuGetPasJeuCourant1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getPasJeuCourrant();
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getPasJeuCourrant() == av + 1);
	}

	/**
	 * Test de l'objectif 25
	 * postcondition de pasJeu : getPasJeuCourant(pasJeu(M, c)) = getPasJeuCourant(M) + 1
	 * cas de test 25.2 : getPasJeuCourant(pasJeu(M, c)) != getPasJeuCourant(M) + 1
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 26
	 * postcondition de pasJeu : getHerosX(pasJeu(M, COMMANDE.GAUCHE)) = min(1, getHerosX(M)  1)
	 * cas de test 26.1 : getHerosX(pasJeu(M, COMMANDE.GAUCHE)) = min(1, getHerosX(M)  1)
	 */
	@Test
	public void testPostcondPasJeuGetHerosX1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosX();
			this.moteurJeu.pasJeu(Commande.GAUCHE, true);
		} catch (ContractException e) {
			e.printStackTrace();
			Assert.fail("MoteurJeu 26.1 : envoi erratique d'exception sur postcondition sur getHerosX.");
		}
		assertTrue(this.moteurJeu.getHerosX() == Math.min(1, av - 1));
	}

	/**
	 * Test de l'objectif 26
	 * postcondition de pasJeu : getHerosX(pasJeu(M, COMMANDE.GAUCHE)) = min(1, getHerosX(M) e 1)
	 * cas de test 26.2 : getHerosX(pasJeu(M, COMMANDE.GAUCHE)) != min(1, getHerosX(M) e 1)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 27
	 * postcondition de pasJeu : getHerosX(pasJeu(M, COMMANDE.DROITE)) = 
	 * min(Terrain :getNombreColonnes(getTerrain(M)), getHerosX(M) + 1)
	 * cas de test 27.1 : getHerosX(pasJeu(M, COMMANDE.DROITE)) = 
	 * mmin(Terrain :getNombreColonnes(getTerrain(M)), getHerosX(M) + 1)
	 */
	@Test
	public void testPostcondPasJeuGetHerosX2_1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosX();
			this.moteurJeu.pasJeu(Commande.DROITE, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == Math.min(this.moteurJeu.getTerrain().getNombreColonnes(), av + 1));
	}

	/**
	 * Test de l'objectif 27
	 * postcondition de pasJeu : getHerosX(pasJeu(M, COMMANDE.DROITE)) = 
	 * max(Terrain :getNombreColonnes(getTerrain(M)), getHerosX(M) + 1)
	 * cas de test 27.2 : getHerosX(pasJeu(M, COMMANDE.DROITE)) != 
	 * max(Terrain :getNombreColonnes(getTerrain(M)), getHerosX(M) + 1)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 28
	 * postcondition de pasJeu : (c != COMMANDE.GAUCHE et c != COMMANDE.DROITE) => 
	 * getHerosX(pasJeu(M, c)) = getHerosX(M)
	 * cas de test 28.1 : (c != COMMANDE.GAUCHE et c != COMMANDE.DROITE) => 
	 * getHerosX(pasJeu(M, c)) = getHerosX(M)
	 */
	@Test
	public void testPostcondPasJeuGetHerosX3_1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosX();
			this.moteurJeu.pasJeu(Commande.HAUT, true);
			this.moteurJeu.pasJeu(Commande.BAS, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosX() == av);
	}

	/**
	 * Test de l'objectif 28
	 * postcondition de pasJeu : (c != COMMANDE.GAUCHE et c != COMMANDE.DROITE) => 
	 * getHerosX(pasJeu(M, c)) = getHerosX(M)
	 * cas de test 28.2 : (c != COMMANDE.GAUCHE et c != COMMANDE.DROITE) => 
	 * getHerosX(pasJeu(M, c)) != getHerosX(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 29
	 * postcondition de pasJeu : getHerosY(pasJeu(M, COMMANDE.HAUT)) = min(1, getHerosY(M) e 1)
	 * cas de test 29.1 : getHerosY(pasJeu(M, COMMANDE.HAUT)) = min(1, getHerosY(M) e 1)
	 */
	@Test
	public void testPostcondPasJeuGetHerosY1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosY();
			this.moteurJeu.pasJeu(Commande.HAUT, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == Math.min(1, av + 1));
	}

	/**
	 * Test de l'objectif 29
	 * postcondition de pasJeu : getHerosY(pasJeu(M, COMMANDE.HAUT)) = min(1, getHerosY(M) + 1)
	 * cas de test 29.2 : getHerosY(pasJeu(M, COMMANDE.HAUT)) != min(1, getHerosY(M) + 1)
	 */

	/**
	 * Test de l'objectif 30
	 * postcondition de pasJeu : getHerosY(pasJeu(M, COMMANDE.BAS)) = 
	 * min(Terrain :getNombreLignes(getTerrain(M)), getHerosY(M) + 1)
	 * cas de test 30.1 : getHerosY(pasJeu(M, COMMANDE.BAS)) = 
	 * min(Terrain :getNombreLignes(getTerrain(M)), getHerosY(M) + 1)
	 */
	@Test
	public void testPostcondPasJeuGetHerosY2_1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosY();
			this.moteurJeu.pasJeu(Commande.BAS, true);
		} catch (ContractException e) {
			assertFalse(true);
		}
		assertTrue(this.moteurJeu.getHerosY() == Math.min(this.moteurJeu.getTerrain().getNombreLignes(), av + 1));
	}

	/**
	 * Test de l'objectif 30
	 * postcondition de pasJeu : getHerosY(pasJeu(M, COMMANDE.BAS)) = max(Terrain :getNombreLignes(getTerrain(M)), getHerosY(M) + 1)
	 * cas de test 30.2 : getHerosY(pasJeu(M, COMMANDE.BAS)) != 
	 * max(Terrain :getNombreLignes(getTerrain(M)), getHerosY(M) + 1)
	 */

	/**
	 * Test de l'objectif 31
	 * postcondition de pasJeu : (c != COMMANDE.HAUT et c != COMMANDE.BAS) => getHerosY(pasJeu(M, c)) = getHerosY(M)
	 * cas de test 31.1 : (c != COMMANDE.HAUT et c != COMMANDE.BAS) => getHerosY(pasJeu(M, c)) = getHerosY(M)
	 */
	@Test
	public void testPostcondPasJeuGetHerosY3_1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosY();
			this.moteurJeu.pasJeu(Commande.GAUCHE, true);
			this.moteurJeu.pasJeu(Commande.DROITE, true);
		} catch (ContractException e) {
			fail("MoteurJeu 31.1 : envoi erratique d'exception sur postcondition de pasJeu.");
		}
		assertTrue(this.moteurJeu.getHerosY() == av);
	}

	/**
	 * Test de l'objectif 31
	 * postcondition de pasJeu : (c != COMMANDE.HAUT et c != COMMANDE.BAS) => getHerosY(pasJeu(M, c)) = getHerosY(M)
	 * cas de test 31.2 : (c != COMMANDE.HAUT et c != COMMANDE.BAS) => getHerosY(pasJeu(M, c)) != getHerosY(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 32
	 * postcondition de pasJeu : getHerosForceVitale(pasJeu(M, c)) = getHerosForceVitale(M)
	 * cas de test 32.1 : getHerosForceVitale(pasJeu(M, c)) = getHerosForceVitale(M)
	 */
	@Test
	public void testPostcondPasJeuGetHerosForceVitale1(){
		int av = 0;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			av = this.moteurJeu.getHerosForceVitale();
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			fail("MoteurJeu 32.1 : envoi erratique d'exception sur postcondition de pasJeu");
		}
		assertTrue(this.moteurJeu.getHerosForceVitale() == av);
	}

	/**
	 * Test de l'objectif 32
	 * postcondition de pasJeu : getHerosForceVitale(pasJeu(M, c)) = getHerosForceVitale(M)
	 * cas de test 32.2 : getHerosForceVitale(pasJeu(M, c)) != getHerosForceVitale(M)
	 * On ne peut pas atteindre cet etat
	 */

	/**
	 * Test de l'objectif 33
	 * postcondition de pasJeu : getTerrain(pasJeu(M, c)) = getTerrain(M)
	 * cas de test 33.1 : getTerrain(pasJeu(M, c)) = getTerrain(M)
	 */
	@Test
	public void testPostcondPasJeuGetTerrain1(){
		TerrainService as = null;
		try {
			//conditions initiales
			this.moteurJeu.init(10);
			as = this.moteurJeu.getTerrain();
			this.moteurJeu.pasJeu(Commande.BOMBE, true);
		} catch (ContractException e) {
			fail("MoteurJeu 33.1 : envoi erratique d'exception sur postcondition de pasJeu");
		}
		assertTrue(this.moteurJeu.getTerrain() == as);
	}

	/**
	 * Test de l'objectif 33
	 * postcondition de pasJeu : getTerrain(pasJeu(M, c)) = getTerrain(M)
	 * cas de test 33.2 : getTerrain(pasJeu(M, c)) != getTerrain(M)
	 * On ne peut pas atteindre cet etat
	 */

}


